package controllers

import (
	"encoding/json"
	"strconv"
	"supershare/backend/middleware"
	"supershare/backend/models"

	"github.com/beego/beego/v2/server/web"
)

// PermissionController 权限管理控制器
type PermissionController struct {
	web.Controller
}

// PermissionListRequest 权限列表请求参数
type PermissionListRequest struct {
	Page     int    `json:"page" form:"page"`
	PageSize int    `json:"pageSize" form:"pageSize"`
	Name     string `json:"name" form:"name"`
	Module   string `json:"module" form:"module"`
	Type     string `json:"type" form:"type"`
	Status   int8   `json:"status" form:"status"`
}

// PermissionCreateRequest 创建权限请求参数
type PermissionCreateRequest struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Module      string `json:"module"`
	Type        string `json:"type"`
	Identifier  string `json:"identifier"`
	Method      string `json:"method"`
	ParentId    int64  `json:"parent_id"`
	Sort        int    `json:"sort"`
	Status      int8   `json:"status"`
}

// PermissionUpdateRequest 更新权限请求参数
type PermissionUpdateRequest struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Module      string `json:"module"`
	Type        string `json:"type"`
	Identifier  string `json:"identifier"`
	Method      string `json:"method"`
	ParentId    int64  `json:"parent_id"`
	Sort        int    `json:"sort"`
	Status      int8   `json:"status"`
}

// BatchUpdateParentRequest 批量更新父级权限请求参数
type BatchUpdateParentRequest struct {
	PermissionIds []int64 `json:"permissionIds"`
	ParentId      int64   `json:"parentId"`
}

// List 获取权限列表
func (c *PermissionController) List() {
	// 获取请求参数
	page, _ := strconv.Atoi(c.GetString("page"))
	if page <= 0 {
		page = 1
	}

	pageSize, _ := strconv.Atoi(c.GetString("pageSize"))
	if pageSize <= 0 || pageSize > 100 {
		pageSize = 10
	}

	name := c.GetString("name")
	module := c.GetString("module")
	permType := c.GetString("type")
	status, _ := c.GetInt8("status", -1)

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"msg":     "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 构建过滤条件
	filters := make(map[string]interface{})
	if name != "" {
		filters["name"] = name
	}
	if module != "" {
		filters["module"] = module
	}
	if permType != "" {
		filters["type"] = permType
	}
	if status >= 0 {
		filters["status"] = int8(status)
	}

	// 查询权限列表
	permissions, err := models.GetPermissionList(filters)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    500,
			"msg":     "获取权限列表失败",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"msg":     "获取权限列表成功",
		"success": true,
		"data":    permissions,
	}
	c.ServeJSON()
}

// Create 创建权限
func (c *PermissionController) Create() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"code":    401,
			"msg":     "未授权访问",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 只有总管理员可以创建权限
	if admin.FranchiseId != 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    403,
			"msg":     "没有操作权限",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req PermissionCreateRequest
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    400,
			"msg":     "请求参数错误",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if req.Name == "" || req.Module == "" || req.Type == "" || req.Identifier == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    400,
			"msg":     "权限名称、所属模块、权限类型和权限标识符不能为空",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 如果是API类型，请求方法不能为空
	if req.Type == "api" && req.Method == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    400,
			"msg":     "API类型的权限必须指定请求方法",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 创建权限对象
	permission := &models.Permission{
		Name:        req.Name,
		Description: req.Description,
		Module:      req.Module,
		Type:        req.Type,
		Identifier:  req.Identifier,
		Method:      req.Method,
		ParentId:    req.ParentId,
		Sort:        req.Sort,
		Status:      req.Status,
	}
	permission.BeforeInsert()
	// 保存到数据库
	id, err := models.CreatePermission(permission)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    500,
			"msg":     "创建权限失败",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 清除权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"msg":     "创建权限成功",
		"success": true,
		"data":    map[string]interface{}{"id": id},
	}
	c.ServeJSON()
}

// Update 更新权限
func (c *PermissionController) Update() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"code":    401,
			"msg":     "未授权访问",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 只有总管理员可以更新权限
	if admin.FranchiseId != 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    403,
			"msg":     "没有操作权限",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 获取权限ID
	id, err := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    400,
			"msg":     "无效的权限ID",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 查询权限是否存在
	permission, err := models.GetPermissionById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    404,
			"msg":     "权限不存在",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req PermissionUpdateRequest
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "请求参数错误",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if req.Name == "" || req.Module == "" || req.Type == "" || req.Identifier == "" {
		c.Data["json"] = map[string]interface{}{
			"msg":     "权限名称、所属模块、权限类型和权限标识符不能为空",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 如果是API类型，请求方法不能为空
	if req.Type == "api" && req.Method == "" {
		c.Data["json"] = map[string]interface{}{
			"msg":     "API类型的权限必须指定请求方法",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 更新权限对象
	permission.Name = req.Name
	permission.Description = req.Description
	permission.Module = req.Module
	permission.Type = req.Type
	permission.Identifier = req.Identifier
	permission.Method = req.Method
	permission.ParentId = req.ParentId
	permission.Sort = req.Sort
	permission.Status = req.Status
	permission.BeforeUpdate()
	// 保存到数据库
	err = models.UpdatePermission(permission, "Name", "Description", "Module", "Type", "Identifier", "Method", "ParentId", "Sort", "Status")
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "更新权限失败",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 清除权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"msg":     "更新权限成功",
		"success": true,
	}
	c.ServeJSON()
}

// Delete 删除权限
func (c *PermissionController) Delete() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "未授权访问",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 只有总管理员可以删除权限
	if admin.FranchiseId != 0 {
		c.Data["json"] = map[string]interface{}{
			"msg":     "没有操作权限",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 获取权限ID
	id, err := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"msg":     "无效的权限ID",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 查询权限是否存在
	_, err = models.GetPermissionById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "权限不存在",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 删除权限
	err = models.DeletePermission(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "删除权限失败",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 清除权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"msg":     "删除权限成功",
		"success": true,
	}
	c.ServeJSON()
}

// BatchUpdateParent 批量更新权限的父级ID
func (c *PermissionController) BatchUpdateParent() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "未授权访问",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 只有总管理员可以批量更新权限
	if admin.FranchiseId != 0 {
		c.Data["json"] = map[string]interface{}{
			"msg":     "没有操作权限",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req BatchUpdateParentRequest
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "请求参数错误",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if len(req.PermissionIds) == 0 {
		c.Data["json"] = map[string]interface{}{
			"msg":     "权限ID列表不能为空",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 批量更新权限的父级ID
	for _, permissionId := range req.PermissionIds {
		// 查询权限是否存在
		permission, err := models.GetPermissionById(permissionId)
		if err != nil {
			continue // 跳过不存在的权限
		}

		// 更新父级ID
		permission.ParentId = req.ParentId
		permission.BeforeUpdate()
		// 保存到数据库
		err = models.UpdatePermission(permission, "ParentId")
		if err != nil {
			// 记录错误但继续处理其他权限
			continue
		}
	}

	// 清除权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"msg":     "批量更新权限父级成功",
		"success": true,
	}
	c.ServeJSON()
}

// GetModules 获取所有模块列表
func (c *PermissionController) GetModules() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "未授权访问",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 获取所有权限
	permissions, err := models.GetPermissionList(map[string]interface{}{})
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"msg":     "获取模块列表失败",
			"success": false,
		}
		c.ServeJSON()
		return
	}

	// 提取模块信息
	moduleMap := make(map[string]string)
	for _, p := range permissions {
		if p.Module != "" {
			moduleMap[p.Module] = p.Module
		}
	}

	// 转换为数组
	modules := make([]map[string]string, 0)
	for code := range moduleMap {
		modules = append(modules, map[string]string{
			"code": code,
			"name": code,
		})
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"msg":     "获取模块列表成功",
		"success": true,
		"data":    modules,
	}
	c.ServeJSON()
}
